Python 的函数编程

Python 中的闭包

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

add_five = outer_function(5)
result = add_five(3)  # 结果为 8

lambda 的写法

lambda arguments : expression

具体使用例：

x = lambda a : a + 10
print(x(5))

x = lambda a, b : a * b
print(x(5, 6))

# Lambda 搭配函数的用法（返回一个模板 Lambda，使之变成一个函数）
def myfunc(n):
  return lambda a : a * n

newFun = myfunc(2)

print(newFun(11))

管道和组合写法

函数式编程支持函数的组合和管道，允许你将多个函数链接在一起以进行数据处理。

def double(x):
    return x * 2

def square(x):
    return x**2

pipeline = lambda x: square(double(x))
result = pipeline(3)  # 先翻倍再平方，结果为 36

Python 实现柯里化

柯里化（Currying）是一种函数式编程技术，它将接受多个参数的函数转化为一系列只接受一个参数的函数。在Python中，你可以使用闭包和嵌套函数来实现柯里化。

以下是一个简单的示例，演示了如何使用Python实现柯里化：

# 定义一个普通的函数，接受三个参数
def add(x, y, z):
    return x + y + z

# 实现柯里化的函数
def curry_add(x):
    def step1(y):
        def step2(z):
            return x + y + z
        return step2
    return step1

# 使用柯里化后的函数
curried_add = curry_add(1)
add_two = curried_add(2)
result = add_two(3)

print(result)  # 输出 6

在上面的示例中，我们首先定义了一个普通的函数 add，它接受三个参数。然后，我们定义了一个柯里化函数 curry_add，它接受一个参数 x，并返回一个嵌套的函数 step1。step1 也是一个函数，它接受一个参数 y，并返回另一个嵌套的函数 step2，最终返回 x + y + z 的结果。通过嵌套的方式，我们可以将多参数函数拆分为一系列只接受一个参数的函数。

最后，我们通过分别调用 curried_add(1)、curried_add(1)(2) 和 curried_add(1)(2)(3) 来完成柯里化，并获得最终的结果。

这只是一个简单的示例，实际上，柯里化可以用于更复杂的函数，使代码更具可读性和可维护性。柯里化是函数式编程中的重要概念，可用于创建高度抽象和可组合的函数。

yield 关键字

yield 是一个类似 return 的关键字，迭代一次遇到 yield 时就返回 yield 后面(右边)的值

scrapy 中的 yield

def parse 是个迭代器，拿来多次执行迭代输出的内容，for(yield) 是抓取当前 response 的里面链接，再进行子request，不断执行 parse，是个递归。

def parse(self, response):
    for url in response.xpath("//a/@href").extract():
        yield scrapy.Request(url, callback=self.parse)

实际上等价于：

def parse(self, response):
    result_list = []

    for url in response.xpath("//a/@href").extract():
        result_list.append(scrapy.Request(url, callback=self.parse))

    return result_list

区别在于用了 yield 的函数会返回一个生成器，生成器不会一次把所有值全部返回，而是每调用一次 next 返回一个值。